﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include <stdlib.h>
#include<Windows.h>
//#include <time.h>
//int main()
//{
//	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int k = 7;
//	int left = 0;
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int right = sz - 1;
//
//	while (left <= right)
//	{
//		int mid = (left + right) / 2;因为mid循环一次就会发生改变，放在while循环外就不会改变了
//		if (arr[mid] < k)
//		{
//			left = mid + 1;
//		}
//		else if (arr[mid] > k)
//		{
//			right = mid - 1;
//		}
//		else
//		{
//			printf("找到了，下标是：%d\n", mid);
//          break;
//		}
//	}
//	if (left > right)
//	{
//		printf("找不到了\n");
//	}
//	return 0;
//}

//
//void menu()
//{
//	printf("1.play\n");
//	printf("0.exit\n");
//}
//void game()
//{
//	int guess = 0;
//	int random_num = rand() % 100 + 1;
//	printf("请猜一个数字\n");
//	do
//	{
//		scanf("%d", &guess);
//		if (guess > random_num)
//		{
//			printf("猜大了，请重新猜\n");
//		}
//		else if (guess < random_num)
//		{
//			printf("猜小了，请重新猜\n");
//		}
//		else
//		{
//			printf("恭喜你，你猜对了\n");
//			break;
//		}
//	} while (1);
//}
//int main()
//{
//	 int input = 0;
//	 srand((unsigned)time(NULL));
//	 do
//	 {
//		 menu();
//		 printf("请输入\n");
//		 scanf("%d", &input);
//		 switch (input)
//		 {
//		 case 1:
//			 game();
//			 break;
//		 case 0:
//			 printf("退出游戏\n");
//			 break;
//		 default:
//			 printf("输入错误，请重新输入\n");
//			 break;
//		 }
//	 } while (input);
//	return 0;
//}


//int main()
//{
//	char arr1[] = "welcome to bit...";
//	char arr2[] = "#################";
//	printf("%s\n", arr2);
//	int left = 0;
//	int right = strlen(arr2)-1;
//	while (left <= right)
//	{
//		arr2[left] = arr1[left];
//		arr2[right] = arr1[right];
//
//		printf("%s\n", arr2);
//		Sleep(1000);
//		system("cls");
//		left++;
//		right--;
//	}
//	return 0;
//}

//int main()
//{
//	printf("请输入密码\n");//假设密码是123456
//	int i = 0;
//	char password[20] = { 0 };
//	for (i = 1; i <= 3; i++)
//	{
//		scanf("%s", &password);
//		if (strcmp(password,"123456")!=0)
//		{
//			printf("输入错误，请重新输入\n");
//		}
//		else
//		{
//			printf("登录成功\n");
//			break;
//		}
//	}
//	if (4 == i)
//	{
//		printf("已输错3次，请休息一下\n");
//	}
//	return 0;
//}

//int main()
//{
//    char ch = '0';
//    char cp = '0';
//    while (scanf("%s", &ch) != EOF)
//    {
//
//        if (ch >= 'A' && ch<='Z')
//        {
//            cp = ch + 32;
//            printf("%c\n", cp);
//        }
//        getchar();
//    }
//    return 0;
//}

//社区版VS

//int main()
//{
//	int a = 0;
//	for (a=1;a<10;a++)
//	{
//		int i = 0;
//		for (i = 1; i <= a; i++)
//		{
//
//			printf("%dX%d=%-2d ", a, i, a * i);
//		}
//		printf("\n");
//	}
//	return 0;
//}

//输出负数的个数，和所有正整数的平均值。
//int main()
//{
//	int n = 0;
//	while (scanf("%d", &n) != EOF)
//	{
//		int a = 0;
//		int i = 0;
//		float sum = 0.0;
//		int count1 = 0;
//		int count2 = 0;
//		for (i = 0; i < n; i++)
//		{
//			scanf("%d", &a);
//			if (a < 0)
//			{
//				count1++;
//			}
//			else if(a > 0)
//			{
//				sum = sum + a;
//				count2++;
//			}
//		}
//		printf("%d %.1lf\n", count1, sum / count2);
//	}
//	return 0;
//}

//有一个长度为 n 的非降序数组，比如[1, 2, 3, 4, 5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，
//变成一个旋转数组，比如变成了[3, 4, 5, 1, 2]，或者[4, 5, 1, 2, 3]这样的。请问，给定这样一个旋转数组，求数组中的最小值
//rotateArray是一维数组  rotateArrayLen数组长度
//int minNumberInRotateArray(int* rotateArray, int rotateArrayLen) 
//{
//    int i = 0;
//    int min = *rotateArray;
//    for (i = 0; i < rotateArrayLen-1; i++)
//    {
//        rotateArray++;
//        if (*rotateArray < min)
//        {
//            min = *rotateArray;
//        }
//    }
//    return min;
//}
//int main()
//{
//    int arr[] = { 3,4,5,6,1,2 };
//    int a = sizeof(arr) / sizeof(arr[0]);
//    int min = minNumberInRotateArray(arr, a);
//    printf("%d\n", min);
//    return 0;
//}

//1. 密码只能由大写字母，小写字母，数字构成；
//2. 密码不能以数字开头；//
//3. 密码中至少出现大写字母，小写字母和数字这三种字符类型中的两种；//
//4. 密码长度至少为8 //
//输入n行，如果密码合法，输出YES，不合法输出NO
//int main()
//{
//	char password[101] = { 0 };
//	int n = 0;
//	while (~scanf("%d", &n))
//	{
//		for (int i = 0; i < n; i++)
//		{
//			scanf("%s", password);
//			int len = strlen(password);
//			int count = 0;
//			if (len < 8 || (password[0] >= '0' && password[0] <= '9'))
//			{
//				printf("NO\n");
//			}
//			else
//			{
//				int j = 0;
//				int SZ = 0;
//				int DX = 0;
//				int XX = 0;
//
//				for (j = 0; j < len; j++)
//				{
//					if (password[j] >= '0' && password[j] <= '9')
//					{
//						SZ++;
//						count++;
//						continue;
//					}
//					if (password[j] >= 'a' && password[j] <= 'z')
//					{
//						XX++;
//						count++;
//						continue;
//					}
//					if (password[j] >= 'A' && password[j] <= 'Z')
//					{
//						DX++;
//						count++;
//						continue;
//					}
//				}
//				if ((SZ == 0 && XX == 0) || (SZ == 0 && DX == 0) || (XX == 0 && DX == 0))
//				{
//					printf("NO\n");
//				}
//				else
//				{
//					if (count == len)
//					{
//						printf("YES\n");
//					}
//				}
//			}
//		}
//
//	}
//	return 0;
//}

//示例：输入：nums = [1, 2, 2, 4] 输入：nums = [1, 1] 输出：[2, 3] 输出：[1, 2]
//1、集合 s 包含从 1 到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外
//一个数字的值，导致集合丢失了一个数字 并且有一个数字重复 。
//给定一个数组 nums 代表了集合 S 发生错误后的结果。
//请你找出重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。
//int* findErrorNums(int* nums, int numsSize, int* returnSize) 
//{
//
//}
//int main()
//{
//	int nums[] = { 1,2,2,4 };
//	//             0 1 2 3   nums[numSize-1]-nums[numSize-2]==1
//	int numSize = sizeof(nums) / sizeof(nums[0]);
//	int j = 0;
//	findErrorNums(nums, numSize, j);
//
//}

//data int整型一维数组
// dataLen int data数组长度
// k int整型
//给定一个长度为 n 的非降序数组和一个非负数整数 k ，要求统计 k 在数组中出现的次数
//int GetNumberOfK(int* data, int dataLen, int k) 
//{
//    int i = 0;
//    int count = 0;
//    for (i = 0; i < dataLen; i++)
//    {
//        if (*(data + i) == k)
//        {
//            count++;
//        }
//    }
//    return count;
//}
//int main()
//{
//    int data[] = { 1,2,3,3,3,3,4,5 };
//    int k = 0;
//    scanf("%d", &k);
//    int dataLen = sizeof(data) / sizeof(data[0]);
//    int ret = GetNumberOfK(data, dataLen, k);
//    printf("%d\n", ret);
//    return 0;
//}

//整数转换。编写一个函数，确定需要改变几个位才能将整数A转成整数B
//int convertInteger(int A, int B) 
//{
//	int tmp = A ^ B;
//	int count = 0;
//	for (int j = 0; j < 32; j++)
//	{
//		if (tmp & 1 == 1)
//		{
//			count++;
//		}
//		tmp = tmp >> 1;
//	}
//	return count;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d%d", &a, &b);
//	int ret = convertInteger(a, b);
//	printf("%d\n", ret);
//	return 0;
//}

//给你一个整数数组nums，其中总是存在唯一的一个最大整数 。
//请你找出数组中的最大元素并检查它是否至少是数组中每个其他数字的两倍 。
//如果是，则返回最大元素的下标，否则返回-1 。
//int dominantIndex(int* nums, int numsSize) 
//{
//	int max = *nums;
//	int count = 0;
//	int ret = 0;
//	for (int j = 0; j < numsSize; j++)
//	{
//		if (max < *(nums + j))
//		{
//			max = *(nums + j);
//			ret = j;
//		}
//	}
//	for (int i = 0; i < numsSize; i++)
//	{
//		if (max != *(nums + i) && max < 2 * *(nums + i))
//		{
//			return -1;
//		}
//	}
//	return ret;
//}
//int main()
//{
//	int nums[] = { 1 };
//	int numsSize = sizeof(nums) / sizeof(nums[0]);
//	int ret = dominantIndex(nums, numsSize);
//	printf("%d\n", ret);
//	return 0;
//}

//Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024
//int main()
//{
//	char arr[1024] = { 0 };
//	while (scanf("%s",arr) != EOF)
//	{
//		int len = strlen(arr);
//		for (int j = 0; j < len - 1; j++)
//		{
//			for (int i = 0; i < len - 1 - j; i++)
//			{
//				if (arr[i] > arr[i + 1])
//				{
//					int tmp = arr[i];
//					arr[i] = arr[i + 1];
//					arr[i + 1] = tmp;
//				}
//			}
//		}
//		printf("%s\n", arr);
//	}
//	return 0;
//}

//给你一个整数数组 nums ，请计算数组的中心下标 。
//数组中心下标是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
//如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数
//组最右端同样适用。
//如果数组有多个中心下标，应该返回最靠近左边 的那一个。如果数组不存在中心下标，返回-1 。

//int pivotIndex(int* nums, int numsSize) 
//{
//	int left = 0;int right = numsSize - 1;int sum1 = 0;int sum2 = 0;
//	//判断中心下标是否在最左端
//	for (int i = 1; i <= right; i++)
//		sum1 += *(nums + i);
//	if (sum1 == 0)
//		return 0;
//	//假设mid重1开始依次向右移动
//	for (int mid = 1; mid < right; mid++)
//	{
//		int sumleft = 0;
//		int sumright = 0;
//		for (int a = 0; a < mid; a++)
//		{
//			sumleft += *(nums + a);
//		}
//		for (int b = right; b > mid; b--)
//		{
//			sumright += *(nums + b);
//		}
//		if (sumleft == sumright)
//			return mid;
//	}
//	//判断中心下标是否在最右端
//	for (int j = right - 1; j >= 0; j--)
//	{
//		sum2 += *(nums + j);
//	}
//	if (sum2 == 0)
//		return right;
//	return -1;
//}
//int main()
//{
//	int nums[] = { 1,2,3 };
//	int numsSize = sizeof(nums) / sizeof(nums[0]);
//	int ret = pivotIndex(nums, numsSize);
//	printf("%d\n", ret);
//	return 0;
//}

//编写一个函数，计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内(0~127 ，包括 0 和 127)，
//换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
//例如，对于字符串 abaca 而言，有 a、b、c 三种不同的字符，因此输出 3 。
//2 
//int main()
//{
//	char arr[500] = { 0 };
//	scanf("%s", &arr);
//	int count = 0;int len = strlen(arr);char copy[500] = { 0 };int j = 0;int k = 0;
//	for (int i = 0; i < len ; i++)
//	{
//
//		for (k = 0; k < j; k++)
//		{
//			if (arr[i] == copy[k])
//				break;
//		}
//		if (arr[i] == copy[k])
//		{
//			continue;
//		}
//			copy[j] = arr[i];
//			j++;
//	}
//	printf("%d\n", j);
//	return 0;
//}

//给定一个大小为n的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n / 2 ⌋ 的元素。
//你可以假设数组是非空的，并且给定的数组总是存在多数元素。
//输入：[3, 2, 3] 输出：3        输入：[2, 2, 1, 1, 1, 2, 2] 输出：2  
//int majorityElement(int* nums, int numsSize) 
//{
//	int count = 1; 
//	int tmp = nums[0]; 
//	for (int i = 1; i < numsSize; i++) 
//	{
//		if (tmp == nums[i]) 
//		{
//			//与保存的字符相同则计数+1 
//			count++; 
//		}
//		else 
//		{//与保存的字符不同则计数-1 
//			count--; 
//			//计数为0表示有可能保存的字符不是最多的字符，换下一个 
//			if (count == 0) 
//				tmp = nums[i + 1]; 
//		} 
//	}
//	return tmp;
//}

//int main()
//{
//	int nums[] = { 4,3,3 };
//	int numsSize = sizeof(nums) / sizeof(nums[0]);
//	int ret = majorityElement(nums, numsSize);
//	printf("%d\n", ret);
//	return 0;
//}
//

//给定一个二进制数组 nums ， 计算其中最大连续 1 的个数
//int findMaxConsecutiveOnes(int* nums, int numsSize) 
//{
//	int count = 0;
//	int tmp = 0;
//	for (int i = 0; i < numsSize; i++)
//	{
//		if (*(nums + i) == 1)
//		{
//			count++;
//		}
//		else
//		{
//			if (tmp < count)
//			{
//				tmp = count;
//			}
//			count = 0;
//		}
//	}
//	if (tmp < count)
//	{
//		tmp = count;
//	}
//	return tmp;
//}
//int main()
//{
//	int nums[] = { 1,0,1,1,0,1 };
//	int numsSize = sizeof(nums) / sizeof(nums[0]);
//	int ret = findMaxConsecutiveOnes(nums, numsSize);
//	printf("%d\n", ret);
//	return 0;
//}

//它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。
//例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。
//输入一个数字n,输出不超过n的完全数的个数
//int main()
//{
//	int n = 0;
//	while (scanf("%d", &n) != EOF)
//	{
//		//产生1——n的数
//		int count = 0;
//		for (int i = 1; i <= n; i++)
//		{
//			//判断是否为真因子
//			int sum = 0;
//			for (int j = 1; j < i; j++)
//			{
//				if (i % j == 0)
//				{
//					sum += j;
//				}
//			}
//			if (sum == i)
//			{
//				count++;
//			}
//		}
//		printf("%d\n", count);
//	}
//	return 0;
//}

//输入描述：输入一个int整数。
//输出描述：将这个整数以字符串的形式逆序输出。
//int main()
//{
//	int n = 0;
//	while (scanf("%d", &n) != EOF)
//	{
//		if (n == 0) //0不会进入while循环之中
//		{
//			printf("%d", n % 10);
//			printf("\n");
//			continue;
//		}
//		while (n)
//		{
//			printf("%d", n % 10);
//			n /= 10;
//		}
//		printf("\n");
//	}
//	return 0;
//}

//数列的定义如下：数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和。
//输入描述：
//输入数据有多组，每组占一行，由两个整数 n(n < 10000) 和 m(m < 1000) 组成，n和m的含义如前所述。
//输出描述：
//对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留2位小数。
//#include<math.h>
//int main()
//{
//	double n = 0.0;
//	int m = 0;
//	while (scanf("%lf %d", &n, &m) != EOF)
//	{
//		double sum = 0.0;
//		for (int i = 0; i < m; i++)
//		{
//			sum += n;
//			n = sqrt(n);
//		}
//		printf("%.2lf\n", sum);
//	}
//	return 0;
//}

//现在有一个长度为 n 的正整数序列，其中只有一种数值出现了奇数次，其他数值均出现偶数次，请你找出那个出
//现奇数次的数值。
//输入描述：第一行：一个整数n，表示序列的长度。第二行：n个 正 整数ai，两个数中间以空格隔开。
//输出描述：一个数，即在序列中唯一出现奇数次的数值。
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//	int tmp = 0;
//	for (int i = 0; i < n; i++)
//	{
//		int ai = 0;
//		scanf("%d", &ai);
//		tmp = tmp ^ ai;
//	}
//	printf("%d\n", tmp);
//	return 0;
//}

//给定一个长度为n的数组 nums ，请你找到峰值并返回其索引。数组可能包含多个峰值，在这种情况下，返回任何
//一个所在位置即可。
//1.峰值元素是指其值严格大于 左右相邻值的元素。严格大于即不能有等于
//2.假设 nums[-1] = nums[n] = 负无穷小
//3.对于所有有效的 i 都有 nums[i] != nums[i + 1]
//int findPeakElement(int* nums, int numsLen)
//{
//	int i = 1;int ret = 0;int tmp = 0;
//	for (i = 1; i < numsLen-1; i++)
//	{
//		if (*(nums + i) > *(nums + i - 1) && *(nums + i) > *(nums + i + 1))
//		{
//			tmp = 1;
//			break;
//		}
//	}
//	if (tmp == 1)
//		ret = i;
//	else 
//	{
//		if (*(nums) > *(nums + 1)|| numsLen == 1)
//			ret = 0;
//		if (*(nums + numsLen - 1) > *(nums + numsLen - 2))
//			ret = numsLen - 1;
//	}
//	return ret;
//}
//int main()
//{
//	int nums[] = { 8,9,8,7,6,5,4,3,2,1 };
//	int numsLen = sizeof(nums) / sizeof(nums[0]);
//	int ret = findPeakElement(nums, numsLen);
//	printf("%d\n", ret);
//	return 0;
//}

//牛牛以前在老师那里得到了一个正整数数对(x, y), 牛牛忘记他们具体是多少了。
//但是牛牛记得老师告诉过他 x 和 y 均不大于 n, 并且 x 除以 y 的余数大于等于 k 。牛牛希望你能帮他计算一共有多少个可能的数对。
//输入描述：输入包括两个正整数 n, k(1 <= n <= 10 ^ 5, 0 <= k <= n - 1) 。
//输出描述：对于每个测试用例, 输出一个正整数表示可能的数对数量
//int main()
//{
//	int n = 0;
//	int k = 0;
//	int count = 0;
//	scanf("%d %d", &n, &k);
//	for (int x = 1; x <= n; x++)
//	{
//		for (int y = 1; y <= n; y++)
//		{
//			if (x % y >= k)
//			{
//				count++;
//			}
//		}
//	}
//	printf("%d\n", count);
//	return 0;
//}

//输入一个字符串和一个整数 k ，截取字符串的前k个字符并输出
//输入描述：1.输入待截取的字符串  2.输入一个正整数k，代表截取的长度
//输出描述：截取后的字符串
//int main()
//{
//	char ch1[101] = { 0 };
//	while (scanf("%s", ch1) != EOF)
//	{
//		int k = 0;
//		scanf("%d", &k);
//		char ch2[101] = { 0 };
//		for (int i = 0; i < k; i++)
//		{
//			ch2[i] = ch1[i];
//		}
//		printf("%s\n", ch2);
//	}
//	return 0;
//}

//喝汽水，1瓶汽水1元，2个空瓶可以换一瓶汽水，给20元，可以多少汽水（编程实现）
//int main()
//{
//	int money = 0;
//	scanf("%d", &money);
//	int sum = money;
//	int tmp = money;
//	while (tmp)
//	{
//		if (tmp % 2 == 0)
//		{
//			tmp = tmp / 2;
//			sum += tmp;
//		}
//		else
//		{
//			tmp = tmp / 2;
//			sum += tmp;
//			if (tmp != 0)
//			{
//				tmp += 1;
//			}
//		}
//	}
//	printf("%d\n", sum);
//    return 0;
//}

//输入一个整数数组，实现一个函数，
//来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分，
//所有偶数位于数组的后半部分。
//void Adjust(int arr1[],int len)
//{
//	int right = len - 1;
//	int i = 0;
//	int j = 0;
//	for (i = 0; i < right; i++)
//	{
//		for (j = 0; j < right; j++)
//		{
//			if (arr1[j] % 2 != 0)
//				continue;
//			else
//			{
//				int tmp = arr1[j];
//				arr1[j] = arr1[j + 1];
//				arr1[j + 1] = tmp;
//			}
//		}
//	}
//}
//int main()
//{
//	int arr[10] = { 1,2,3,4,5,6,9 };
//	int len = sizeof(arr) / sizeof(arr[0]);
//	Adjust(arr, len);
//	for (int i = 0; i <= len - 1; i++)
//	{
//		printf("%d ", arr[i]);
//	}
//	printf("\n");
//	return 0;
//}

#include<assert.h>

//int my_strlen(const char *str)
//{
//	int count = 0;
//	assert(str != NULL);
//	while (*str++ != '\0')
//	{
//		count++;
//	}
//	return count;
//}
//int main()
//{
//	char arr[] = "abcdef";
//	int len = my_strlen(arr);
//	printf("%d\n", len);
//}

char* my_strcpy(char *dest, const char *src)
{
	assert(dest && src);
	char* ret = dest;
	while (*dest++ = *src++)
	{
		;
	}
	return (dest);
}
int main()
{
	char arr1[] = "hello bit";
	char arr2[] = "################";
	my_strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}
